// This is free and unencumbered software released into the public domain.
// See LICENSE.md for more information.

/**
 * @fileoverview Global |this| required for resolving indexes in node.
 * @suppress {globalThis}
 */
(function (global) {
  'use strict'; // If we're in node require encoding-indexes and attach it to the global.

  if (typeof module !== "undefined" && module.exports && !global["encoding-indexes"]) {
    global["encoding-indexes"] = require("./encoding-indexes.js")["encoding-indexes"];
  } //
  // Utilities
  //

  /**
   * @param {number} a The number to test.
   * @param {number} min The minimum value in the range, inclusive.
   * @param {number} max The maximum value in the range, inclusive.
   * @return {boolean} True if a >= min and a <= max.
   */


  function inRange(a, min, max) {
    return min <= a && a <= max;
  }
  /**
   * @param {!Array.<*>} array The array to check.
   * @param {*} item The item to look for in the array.
   * @return {boolean} True if the item appears in the array.
   */


  function includes(array, item) {
    return array.indexOf(item) !== -1;
  }

  var floor = Math.floor;
  /**
   * @param {*} o
   * @return {Object}
   */

  function ToDictionary(o) {
    if (o === undefined) return {};
    if (o === Object(o)) return o;
    throw TypeError('Could not convert argument to dictionary');
  }
  /**
   * @param {string} string Input string of UTF-16 code units.
   * @return {!Array.<number>} Code points.
   */


  function stringToCodePoints(string) {
    // https://heycam.github.io/webidl/#dfn-obtain-unicode
    // 1. Let S be the DOMString value.
    var s = String(string); // 2. Let n be the length of S.

    var n = s.length; // 3. Initialize i to 0.

    var i = 0; // 4. Initialize U to be an empty sequence of Unicode characters.

    var u = []; // 5. While i < n:

    while (i < n) {
      // 1. Let c be the code unit in S at index i.
      var c = s.charCodeAt(i); // 2. Depending on the value of c:
      // c < 0xD800 or c > 0xDFFF

      if (c < 0xD800 || c > 0xDFFF) {
        // Append to U the Unicode character with code point c.
        u.push(c);
      } // 0xDC00 ≤ c ≤ 0xDFFF
      else if (0xDC00 <= c && c <= 0xDFFF) {
          // Append to U a U+FFFD REPLACEMENT CHARACTER.
          u.push(0xFFFD);
        } // 0xD800 ≤ c ≤ 0xDBFF
        else if (0xD800 <= c && c <= 0xDBFF) {
            // 1. If i = n−1, then append to U a U+FFFD REPLACEMENT
            // CHARACTER.
            if (i === n - 1) {
              u.push(0xFFFD);
            } // 2. Otherwise, i < n−1:
            else {
                // 1. Let d be the code unit in S at index i+1.
                var d = s.charCodeAt(i + 1); // 2. If 0xDC00 ≤ d ≤ 0xDFFF, then:

                if (0xDC00 <= d && d <= 0xDFFF) {
                  // 1. Let a be c & 0x3FF.
                  var a = c & 0x3FF; // 2. Let b be d & 0x3FF.

                  var b = d & 0x3FF; // 3. Append to U the Unicode character with code point
                  // 2^16+2^10*a+b.

                  u.push(0x10000 + (a << 10) + b); // 4. Set i to i+1.

                  i += 1;
                } // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a
                // U+FFFD REPLACEMENT CHARACTER.
                else {
                    u.push(0xFFFD);
                  }
              }
          } // 3. Set i to i+1.


      i += 1;
    } // 6. Return U.


    return u;
  }
  /**
   * @param {!Array.<number>} code_points Array of code points.
   * @return {string} string String of UTF-16 code units.
   */


  function codePointsToString(code_points) {
    var s = '';

    for (var i = 0; i < code_points.length; ++i) {
      var cp = code_points[i];

      if (cp <= 0xFFFF) {
        s += String.fromCharCode(cp);
      } else {
        cp -= 0x10000;
        s += String.fromCharCode((cp >> 10) + 0xD800, (cp & 0x3FF) + 0xDC00);
      }
    }

    return s;
  } //
  // Implementation of Encoding specification
  // https://encoding.spec.whatwg.org/
  //
  //
  // 4. Terminology
  //

  /**
   * An ASCII byte is a byte in the range 0x00 to 0x7F, inclusive.
   * @param {number} a The number to test.
   * @return {boolean} True if a is in the range 0x00 to 0x7F, inclusive.
   */


  function isASCIIByte(a) {
    return 0x00 <= a && a <= 0x7F;
  }
  /**
   * An ASCII code point is a code point in the range U+0000 to
   * U+007F, inclusive.
   */


  var isASCIICodePoint = isASCIIByte;
  /**
   * End-of-stream is a special token that signifies no more tokens
   * are in the stream.
   * @const
   */

  var end_of_stream = -1;
  /**
   * A stream represents an ordered sequence of tokens.
   *
   * @constructor
   * @param {!(Array.<number>|Uint8Array)} tokens Array of tokens that provide
   * the stream.
   */

  function Stream(tokens) {
    /** @type {!Array.<number>} */
    this.tokens = [].slice.call(tokens); // Reversed as push/pop is more efficient than shift/unshift.

    this.tokens.reverse();
  }

  Stream.prototype = {
    /**
     * @return {boolean} True if end-of-stream has been hit.
     */
    endOfStream: function () {
      return !this.tokens.length;
    },

    /**
     * When a token is read from a stream, the first token in the
     * stream must be returned and subsequently removed, and
     * end-of-stream must be returned otherwise.
     *
     * @return {number} Get the next token from the stream, or
     * end_of_stream.
     */
    read: function () {
      if (!this.tokens.length) return end_of_stream;
      return this.tokens.pop();
    },

    /**
     * When one or more tokens are prepended to a stream, those tokens
     * must be inserted, in given order, before the first token in the
     * stream.
     *
     * @param {(number|!Array.<number>)} token The token(s) to prepend to the
     * stream.
     */
    prepend: function (token) {
      if (Array.isArray(token)) {
        var tokens =
        /**@type {!Array.<number>}*/
        token;

        while (tokens.length) this.tokens.push(tokens.pop());
      } else {
        this.tokens.push(token);
      }
    },

    /**
     * When one or more tokens are pushed to a stream, those tokens
     * must be inserted, in given order, after the last token in the
     * stream.
     *
     * @param {(number|!Array.<number>)} token The tokens(s) to push to the
     * stream.
     */
    push: function (token) {
      if (Array.isArray(token)) {
        var tokens =
        /**@type {!Array.<number>}*/
        token;

        while (tokens.length) this.tokens.unshift(tokens.shift());
      } else {
        this.tokens.unshift(token);
      }
    }
  }; //
  // 5. Encodings
  //
  // 5.1 Encoders and decoders

  /** @const */

  var finished = -1;
  /**
   * @param {boolean} fatal If true, decoding errors raise an exception.
   * @param {number=} opt_code_point Override the standard fallback code point.
   * @return {number} The code point to insert on a decoding error.
   */

  function decoderError(fatal, opt_code_point) {
    if (fatal) throw TypeError('Decoder error');
    return opt_code_point || 0xFFFD;
  }
  /**
   * @param {number} code_point The code point that could not be encoded.
   * @return {number} Always throws, no value is actually returned.
   */


  function encoderError(code_point) {
    throw TypeError('The code point ' + code_point + ' could not be encoded.');
  }
  /** @interface */


  function Decoder() {}

  Decoder.prototype = {
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point, or |finished|.
     */
    handler: function (stream, bite) {}
  };
  /** @interface */

  function Encoder() {}

  Encoder.prototype = {
    /**
     * @param {Stream} stream The stream of code points being encoded.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit, or |finished|.
     */
    handler: function (stream, code_point) {}
  }; // 5.2 Names and labels
  // TODO: Define @typedef for Encoding: {name:string,labels:Array.<string>}
  // https://github.com/google/closure-compiler/issues/247

  /**
   * @param {string} label The encoding label.
   * @return {?{name:string,labels:Array.<string>}}
   */

  function getEncoding(label) {
    // 1. Remove any leading and trailing ASCII whitespace from label.
    label = String(label).trim().toLowerCase(); // 2. If label is an ASCII case-insensitive match for any of the
    // labels listed in the table below, return the corresponding
    // encoding, and failure otherwise.

    if (Object.prototype.hasOwnProperty.call(label_to_encoding, label)) {
      return label_to_encoding[label];
    }

    return null;
  }
  /**
   * Encodings table: https://encoding.spec.whatwg.org/encodings.json
   * @const
   * @type {!Array.<{
   *          heading: string,
   *          encodings: Array.<{name:string,labels:Array.<string>}>
   *        }>}
   */


  var encodings = [{
    "encodings": [{
      "labels": ["unicode-1-1-utf-8", "utf-8", "utf8"],
      "name": "UTF-8"
    }],
    "heading": "The Encoding"
  }, {
    "encodings": [{
      "labels": ["866", "cp866", "csibm866", "ibm866"],
      "name": "IBM866"
    }, {
      "labels": ["csisolatin2", "iso-8859-2", "iso-ir-101", "iso8859-2", "iso88592", "iso_8859-2", "iso_8859-2:1987", "l2", "latin2"],
      "name": "ISO-8859-2"
    }, {
      "labels": ["csisolatin3", "iso-8859-3", "iso-ir-109", "iso8859-3", "iso88593", "iso_8859-3", "iso_8859-3:1988", "l3", "latin3"],
      "name": "ISO-8859-3"
    }, {
      "labels": ["csisolatin4", "iso-8859-4", "iso-ir-110", "iso8859-4", "iso88594", "iso_8859-4", "iso_8859-4:1988", "l4", "latin4"],
      "name": "ISO-8859-4"
    }, {
      "labels": ["csisolatincyrillic", "cyrillic", "iso-8859-5", "iso-ir-144", "iso8859-5", "iso88595", "iso_8859-5", "iso_8859-5:1988"],
      "name": "ISO-8859-5"
    }, {
      "labels": ["arabic", "asmo-708", "csiso88596e", "csiso88596i", "csisolatinarabic", "ecma-114", "iso-8859-6", "iso-8859-6-e", "iso-8859-6-i", "iso-ir-127", "iso8859-6", "iso88596", "iso_8859-6", "iso_8859-6:1987"],
      "name": "ISO-8859-6"
    }, {
      "labels": ["csisolatingreek", "ecma-118", "elot_928", "greek", "greek8", "iso-8859-7", "iso-ir-126", "iso8859-7", "iso88597", "iso_8859-7", "iso_8859-7:1987", "sun_eu_greek"],
      "name": "ISO-8859-7"
    }, {
      "labels": ["csiso88598e", "csisolatinhebrew", "hebrew", "iso-8859-8", "iso-8859-8-e", "iso-ir-138", "iso8859-8", "iso88598", "iso_8859-8", "iso_8859-8:1988", "visual"],
      "name": "ISO-8859-8"
    }, {
      "labels": ["csiso88598i", "iso-8859-8-i", "logical"],
      "name": "ISO-8859-8-I"
    }, {
      "labels": ["csisolatin6", "iso-8859-10", "iso-ir-157", "iso8859-10", "iso885910", "l6", "latin6"],
      "name": "ISO-8859-10"
    }, {
      "labels": ["iso-8859-13", "iso8859-13", "iso885913"],
      "name": "ISO-8859-13"
    }, {
      "labels": ["iso-8859-14", "iso8859-14", "iso885914"],
      "name": "ISO-8859-14"
    }, {
      "labels": ["csisolatin9", "iso-8859-15", "iso8859-15", "iso885915", "iso_8859-15", "l9"],
      "name": "ISO-8859-15"
    }, {
      "labels": ["iso-8859-16"],
      "name": "ISO-8859-16"
    }, {
      "labels": ["cskoi8r", "koi", "koi8", "koi8-r", "koi8_r"],
      "name": "KOI8-R"
    }, {
      "labels": ["koi8-ru", "koi8-u"],
      "name": "KOI8-U"
    }, {
      "labels": ["csmacintosh", "mac", "macintosh", "x-mac-roman"],
      "name": "macintosh"
    }, {
      "labels": ["dos-874", "iso-8859-11", "iso8859-11", "iso885911", "tis-620", "windows-874"],
      "name": "windows-874"
    }, {
      "labels": ["cp1250", "windows-1250", "x-cp1250"],
      "name": "windows-1250"
    }, {
      "labels": ["cp1251", "windows-1251", "x-cp1251"],
      "name": "windows-1251"
    }, {
      "labels": ["ansi_x3.4-1968", "ascii", "cp1252", "cp819", "csisolatin1", "ibm819", "iso-8859-1", "iso-ir-100", "iso8859-1", "iso88591", "iso_8859-1", "iso_8859-1:1987", "l1", "latin1", "us-ascii", "windows-1252", "x-cp1252"],
      "name": "windows-1252"
    }, {
      "labels": ["cp1253", "windows-1253", "x-cp1253"],
      "name": "windows-1253"
    }, {
      "labels": ["cp1254", "csisolatin5", "iso-8859-9", "iso-ir-148", "iso8859-9", "iso88599", "iso_8859-9", "iso_8859-9:1989", "l5", "latin5", "windows-1254", "x-cp1254"],
      "name": "windows-1254"
    }, {
      "labels": ["cp1255", "windows-1255", "x-cp1255"],
      "name": "windows-1255"
    }, {
      "labels": ["cp1256", "windows-1256", "x-cp1256"],
      "name": "windows-1256"
    }, {
      "labels": ["cp1257", "windows-1257", "x-cp1257"],
      "name": "windows-1257"
    }, {
      "labels": ["cp1258", "windows-1258", "x-cp1258"],
      "name": "windows-1258"
    }, {
      "labels": ["x-mac-cyrillic", "x-mac-ukrainian"],
      "name": "x-mac-cyrillic"
    }],
    "heading": "Legacy single-byte encodings"
  }, {
    "encodings": [{
      "labels": ["chinese", "csgb2312", "csiso58gb231280", "gb2312", "gb_2312", "gb_2312-80", "gbk", "iso-ir-58", "x-gbk"],
      "name": "GBK"
    }, {
      "labels": ["gb18030"],
      "name": "gb18030"
    }],
    "heading": "Legacy multi-byte Chinese (simplified) encodings"
  }, {
    "encodings": [{
      "labels": ["big5", "big5-hkscs", "cn-big5", "csbig5", "x-x-big5"],
      "name": "Big5"
    }],
    "heading": "Legacy multi-byte Chinese (traditional) encodings"
  }, {
    "encodings": [{
      "labels": ["cseucpkdfmtjapanese", "euc-jp", "x-euc-jp"],
      "name": "EUC-JP"
    }, {
      "labels": ["csiso2022jp", "iso-2022-jp"],
      "name": "ISO-2022-JP"
    }, {
      "labels": ["csshiftjis", "ms932", "ms_kanji", "shift-jis", "shift_jis", "sjis", "windows-31j", "x-sjis"],
      "name": "Shift_JIS"
    }],
    "heading": "Legacy multi-byte Japanese encodings"
  }, {
    "encodings": [{
      "labels": ["cseuckr", "csksc56011987", "euc-kr", "iso-ir-149", "korean", "ks_c_5601-1987", "ks_c_5601-1989", "ksc5601", "ksc_5601", "windows-949"],
      "name": "EUC-KR"
    }],
    "heading": "Legacy multi-byte Korean encodings"
  }, {
    "encodings": [{
      "labels": ["csiso2022kr", "hz-gb-2312", "iso-2022-cn", "iso-2022-cn-ext", "iso-2022-kr"],
      "name": "replacement"
    }, {
      "labels": ["utf-16be"],
      "name": "UTF-16BE"
    }, {
      "labels": ["utf-16", "utf-16le"],
      "name": "UTF-16LE"
    }, {
      "labels": ["x-user-defined"],
      "name": "x-user-defined"
    }],
    "heading": "Legacy miscellaneous encodings"
  }]; // Label to encoding registry.

  /** @type {Object.<string,{name:string,labels:Array.<string>}>} */

  var label_to_encoding = {};
  encodings.forEach(function (category) {
    category.encodings.forEach(function (encoding) {
      encoding.labels.forEach(function (label) {
        label_to_encoding[label] = encoding;
      });
    });
  }); // Registry of of encoder/decoder factories, by encoding name.

  /** @type {Object.<string, function({fatal:boolean}): Encoder>} */

  var encoders = {};
  /** @type {Object.<string, function({fatal:boolean}): Decoder>} */

  var decoders = {}; //
  // 6. Indexes
  //

  /**
   * @param {number} pointer The |pointer| to search for.
   * @param {(!Array.<?number>|undefined)} index The |index| to search within.
   * @return {?number} The code point corresponding to |pointer| in |index|,
   *     or null if |code point| is not in |index|.
   */

  function indexCodePointFor(pointer, index) {
    if (!index) return null;
    return index[pointer] || null;
  }
  /**
   * @param {number} code_point The |code point| to search for.
   * @param {!Array.<?number>} index The |index| to search within.
   * @return {?number} The first pointer corresponding to |code point| in
   *     |index|, or null if |code point| is not in |index|.
   */


  function indexPointerFor(code_point, index) {
    var pointer = index.indexOf(code_point);
    return pointer === -1 ? null : pointer;
  }
  /**
   * @param {string} name Name of the index.
   * @return {(!Array.<number>|!Array.<Array.<number>>)}
   *  */


  function index(name) {
    if (!('encoding-indexes' in global)) {
      throw Error("Indexes missing." + " Did you forget to include encoding-indexes.js first?");
    }

    return global['encoding-indexes'][name];
  }
  /**
   * @param {number} pointer The |pointer| to search for in the gb18030 index.
   * @return {?number} The code point corresponding to |pointer| in |index|,
   *     or null if |code point| is not in the gb18030 index.
   */


  function indexGB18030RangesCodePointFor(pointer) {
    // 1. If pointer is greater than 39419 and less than 189000, or
    // pointer is greater than 1237575, return null.
    if (pointer > 39419 && pointer < 189000 || pointer > 1237575) return null; // 2. If pointer is 7457, return code point U+E7C7.

    if (pointer === 7457) return 0xE7C7; // 3. Let offset be the last pointer in index gb18030 ranges that
    // is equal to or less than pointer and let code point offset be
    // its corresponding code point.

    var offset = 0;
    var code_point_offset = 0;
    var idx = index('gb18030-ranges');
    var i;

    for (i = 0; i < idx.length; ++i) {
      /** @type {!Array.<number>} */
      var entry = idx[i];

      if (entry[0] <= pointer) {
        offset = entry[0];
        code_point_offset = entry[1];
      } else {
        break;
      }
    } // 4. Return a code point whose value is code point offset +
    // pointer − offset.


    return code_point_offset + pointer - offset;
  }
  /**
   * @param {number} code_point The |code point| to locate in the gb18030 index.
   * @return {number} The first pointer corresponding to |code point| in the
   *     gb18030 index.
   */


  function indexGB18030RangesPointerFor(code_point) {
    // 1. If code point is U+E7C7, return pointer 7457.
    if (code_point === 0xE7C7) return 7457; // 2. Let offset be the last code point in index gb18030 ranges
    // that is equal to or less than code point and let pointer offset
    // be its corresponding pointer.

    var offset = 0;
    var pointer_offset = 0;
    var idx = index('gb18030-ranges');
    var i;

    for (i = 0; i < idx.length; ++i) {
      /** @type {!Array.<number>} */
      var entry = idx[i];

      if (entry[1] <= code_point) {
        offset = entry[1];
        pointer_offset = entry[0];
      } else {
        break;
      }
    } // 3. Return a pointer whose value is pointer offset + code point
    // − offset.


    return pointer_offset + code_point - offset;
  }
  /**
   * @param {number} code_point The |code_point| to search for in the Shift_JIS
   *     index.
   * @return {?number} The code point corresponding to |pointer| in |index|,
   *     or null if |code point| is not in the Shift_JIS index.
   */


  function indexShiftJISPointerFor(code_point) {
    // 1. Let index be index jis0208 excluding all entries whose
    // pointer is in the range 8272 to 8835, inclusive.
    shift_jis_index = shift_jis_index || index('jis0208').map(function (code_point, pointer) {
      return inRange(pointer, 8272, 8835) ? null : code_point;
    });
    var index_ = shift_jis_index; // 2. Return the index pointer for code point in index.

    return index_.indexOf(code_point);
  }

  var shift_jis_index;
  /**
   * @param {number} code_point The |code_point| to search for in the big5
   *     index.
   * @return {?number} The code point corresponding to |pointer| in |index|,
   *     or null if |code point| is not in the big5 index.
   */

  function indexBig5PointerFor(code_point) {
    // 1. Let index be index Big5 excluding all entries whose pointer
    big5_index_no_hkscs = big5_index_no_hkscs || index('big5').map(function (code_point, pointer) {
      return pointer < (0xA1 - 0x81) * 157 ? null : code_point;
    });
    var index_ = big5_index_no_hkscs; // 2. If code point is U+2550, U+255E, U+2561, U+256A, U+5341, or
    // U+5345, return the last pointer corresponding to code point in
    // index.

    if (code_point === 0x2550 || code_point === 0x255E || code_point === 0x2561 || code_point === 0x256A || code_point === 0x5341 || code_point === 0x5345) {
      return index_.lastIndexOf(code_point);
    } // 3. Return the index pointer for code point in index.


    return indexPointerFor(code_point, index_);
  }

  var big5_index_no_hkscs; //
  // 8. API
  //

  /** @const */

  var DEFAULT_ENCODING = 'utf-8'; // 8.1 Interface TextDecoder

  /**
   * @constructor
   * @param {string=} label The label of the encoding;
   *     defaults to 'utf-8'.
   * @param {Object=} options
   */

  function TextDecoder(label, options) {
    // Web IDL conventions
    if (!(this instanceof TextDecoder)) throw TypeError('Called as a function. Did you forget \'new\'?');
    label = label !== undefined ? String(label) : DEFAULT_ENCODING;
    options = ToDictionary(options); // A TextDecoder object has an associated encoding, decoder,
    // stream, ignore BOM flag (initially unset), BOM seen flag
    // (initially unset), error mode (initially replacement), and do
    // not flush flag (initially unset).

    /** @private */

    this._encoding = null;
    /** @private @type {?Decoder} */

    this._decoder = null;
    /** @private @type {boolean} */

    this._ignoreBOM = false;
    /** @private @type {boolean} */

    this._BOMseen = false;
    /** @private @type {string} */

    this._error_mode = 'replacement';
    /** @private @type {boolean} */

    this._do_not_flush = false; // 1. Let encoding be the result of getting an encoding from
    // label.

    var encoding = getEncoding(label); // 2. If encoding is failure or replacement, throw a RangeError.

    if (encoding === null || encoding.name === 'replacement') throw RangeError('Unknown encoding: ' + label);

    if (!decoders[encoding.name]) {
      throw Error('Decoder not present.' + ' Did you forget to include encoding-indexes.js first?');
    } // 3. Let dec be a new TextDecoder object.


    var dec = this; // 4. Set dec's encoding to encoding.

    dec._encoding = encoding; // 5. If options's fatal member is true, set dec's error mode to
    // fatal.

    if (Boolean(options['fatal'])) dec._error_mode = 'fatal'; // 6. If options's ignoreBOM member is true, set dec's ignore BOM
    // flag.

    if (Boolean(options['ignoreBOM'])) dec._ignoreBOM = true; // For pre-ES5 runtimes:

    if (!Object.defineProperty) {
      this.encoding = dec._encoding.name.toLowerCase();
      this.fatal = dec._error_mode === 'fatal';
      this.ignoreBOM = dec._ignoreBOM;
    } // 7. Return dec.


    return dec;
  }

  if (Object.defineProperty) {
    // The encoding attribute's getter must return encoding's name.
    Object.defineProperty(TextDecoder.prototype, 'encoding', {
      /** @this {TextDecoder} */
      get: function () {
        return this._encoding.name.toLowerCase();
      }
    }); // The fatal attribute's getter must return true if error mode
    // is fatal, and false otherwise.

    Object.defineProperty(TextDecoder.prototype, 'fatal', {
      /** @this {TextDecoder} */
      get: function () {
        return this._error_mode === 'fatal';
      }
    }); // The ignoreBOM attribute's getter must return true if ignore
    // BOM flag is set, and false otherwise.

    Object.defineProperty(TextDecoder.prototype, 'ignoreBOM', {
      /** @this {TextDecoder} */
      get: function () {
        return this._ignoreBOM;
      }
    });
  }
  /**
   * @param {BufferSource=} input The buffer of bytes to decode.
   * @param {Object=} options
   * @return {string} The decoded string.
   */


  TextDecoder.prototype.decode = function decode(input, options) {
    var bytes;

    if (typeof input === 'object' && input instanceof ArrayBuffer) {
      bytes = new Uint8Array(input);
    } else if (typeof input === 'object' && 'buffer' in input && input.buffer instanceof ArrayBuffer) {
      bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
    } else {
      bytes = new Uint8Array(0);
    }

    options = ToDictionary(options); // 1. If the do not flush flag is unset, set decoder to a new
    // encoding's decoder, set stream to a new stream, and unset the
    // BOM seen flag.

    if (!this._do_not_flush) {
      this._decoder = decoders[this._encoding.name]({
        fatal: this._error_mode === 'fatal'
      });
      this._BOMseen = false;
    } // 2. If options's stream is true, set the do not flush flag, and
    // unset the do not flush flag otherwise.


    this._do_not_flush = Boolean(options['stream']); // 3. If input is given, push a copy of input to stream.
    // TODO: Align with spec algorithm - maintain stream on instance.

    var input_stream = new Stream(bytes); // 4. Let output be a new stream.

    var output = [];
    /** @type {?(number|!Array.<number>)} */

    var result; // 5. While true:

    while (true) {
      // 1. Let token be the result of reading from stream.
      var token = input_stream.read(); // 2. If token is end-of-stream and the do not flush flag is
      // set, return output, serialized.
      // TODO: Align with spec algorithm.

      if (token === end_of_stream) break; // 3. Otherwise, run these subsubsteps:
      // 1. Let result be the result of processing token for decoder,
      // stream, output, and error mode.

      result = this._decoder.handler(input_stream, token); // 2. If result is finished, return output, serialized.

      if (result === finished) break;

      if (result !== null) {
        if (Array.isArray(result)) output.push.apply(output,
        /**@type {!Array.<number>}*/
        result);else output.push(result);
      } // 3. Otherwise, if result is error, throw a TypeError.
      // (Thrown in handler)
      // 4. Otherwise, do nothing.

    } // TODO: Align with spec algorithm.


    if (!this._do_not_flush) {
      do {
        result = this._decoder.handler(input_stream, input_stream.read());
        if (result === finished) break;
        if (result === null) continue;
        if (Array.isArray(result)) output.push.apply(output,
        /**@type {!Array.<number>}*/
        result);else output.push(result);
      } while (!input_stream.endOfStream());

      this._decoder = null;
    } // A TextDecoder object also has an associated serialize stream
    // algorithm...

    /**
     * @param {!Array.<number>} stream
     * @return {string}
     * @this {TextDecoder}
     */


    function serializeStream(stream) {
      // 1. Let token be the result of reading from stream.
      // (Done in-place on array, rather than as a stream)
      // 2. If encoding is UTF-8, UTF-16BE, or UTF-16LE, and ignore
      // BOM flag and BOM seen flag are unset, run these subsubsteps:
      if (includes(['UTF-8', 'UTF-16LE', 'UTF-16BE'], this._encoding.name) && !this._ignoreBOM && !this._BOMseen) {
        if (stream.length > 0 && stream[0] === 0xFEFF) {
          // 1. If token is U+FEFF, set BOM seen flag.
          this._BOMseen = true;
          stream.shift();
        } else if (stream.length > 0) {
          // 2. Otherwise, if token is not end-of-stream, set BOM seen
          // flag and append token to stream.
          this._BOMseen = true;
        } else {// 3. Otherwise, if token is not end-of-stream, append token
          // to output.
          // (no-op)
        }
      } // 4. Otherwise, return output.


      return codePointsToString(stream);
    }

    return serializeStream.call(this, output);
  }; // 8.2 Interface TextEncoder

  /**
   * @constructor
   * @param {string=} label The label of the encoding. NONSTANDARD.
   * @param {Object=} options NONSTANDARD.
   */


  function TextEncoder(label, options) {
    // Web IDL conventions
    if (!(this instanceof TextEncoder)) throw TypeError('Called as a function. Did you forget \'new\'?');
    options = ToDictionary(options); // A TextEncoder object has an associated encoding and encoder.

    /** @private */

    this._encoding = null;
    /** @private @type {?Encoder} */

    this._encoder = null; // Non-standard

    /** @private @type {boolean} */

    this._do_not_flush = false;
    /** @private @type {string} */

    this._fatal = Boolean(options['fatal']) ? 'fatal' : 'replacement'; // 1. Let enc be a new TextEncoder object.

    var enc = this; // 2. Set enc's encoding to UTF-8's encoder.

    if (Boolean(options['NONSTANDARD_allowLegacyEncoding'])) {
      // NONSTANDARD behavior.
      label = label !== undefined ? String(label) : DEFAULT_ENCODING;
      var encoding = getEncoding(label);
      if (encoding === null || encoding.name === 'replacement') throw RangeError('Unknown encoding: ' + label);

      if (!encoders[encoding.name]) {
        throw Error('Encoder not present.' + ' Did you forget to include encoding-indexes.js first?');
      }

      enc._encoding = encoding;
    } else {
      // Standard behavior.
      enc._encoding = getEncoding('utf-8');

      if (label !== undefined && 'console' in global) {
        console.warn('TextEncoder constructor called with encoding label, ' + 'which is ignored.');
      }
    } // For pre-ES5 runtimes:


    if (!Object.defineProperty) this.encoding = enc._encoding.name.toLowerCase(); // 3. Return enc.

    return enc;
  }

  if (Object.defineProperty) {
    // The encoding attribute's getter must return encoding's name.
    Object.defineProperty(TextEncoder.prototype, 'encoding', {
      /** @this {TextEncoder} */
      get: function () {
        return this._encoding.name.toLowerCase();
      }
    });
  }
  /**
   * @param {string=} opt_string The string to encode.
   * @param {Object=} options
   * @return {!Uint8Array} Encoded bytes, as a Uint8Array.
   */


  TextEncoder.prototype.encode = function encode(opt_string, options) {
    opt_string = opt_string === undefined ? '' : String(opt_string);
    options = ToDictionary(options); // NOTE: This option is nonstandard. None of the encodings
    // permitted for encoding (i.e. UTF-8, UTF-16) are stateful when
    // the input is a USVString so streaming is not necessary.

    if (!this._do_not_flush) this._encoder = encoders[this._encoding.name]({
      fatal: this._fatal === 'fatal'
    });
    this._do_not_flush = Boolean(options['stream']); // 1. Convert input to a stream.

    var input = new Stream(stringToCodePoints(opt_string)); // 2. Let output be a new stream

    var output = [];
    /** @type {?(number|!Array.<number>)} */

    var result; // 3. While true, run these substeps:

    while (true) {
      // 1. Let token be the result of reading from input.
      var token = input.read();
      if (token === end_of_stream) break; // 2. Let result be the result of processing token for encoder,
      // input, output.

      result = this._encoder.handler(input, token);
      if (result === finished) break;
      if (Array.isArray(result)) output.push.apply(output,
      /**@type {!Array.<number>}*/
      result);else output.push(result);
    } // TODO: Align with spec algorithm.


    if (!this._do_not_flush) {
      while (true) {
        result = this._encoder.handler(input, input.read());
        if (result === finished) break;
        if (Array.isArray(result)) output.push.apply(output,
        /**@type {!Array.<number>}*/
        result);else output.push(result);
      }

      this._encoder = null;
    } // 3. If result is finished, convert output into a byte sequence,
    // and then return a Uint8Array object wrapping an ArrayBuffer
    // containing output.


    return new Uint8Array(output);
  }; //
  // 9. The encoding
  //
  // 9.1 utf-8
  // 9.1.1 utf-8 decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function UTF8Decoder(options) {
    var fatal = options.fatal; // utf-8's decoder's has an associated utf-8 code point, utf-8
    // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8
    // lower boundary (initially 0x80), and a utf-8 upper boundary
    // (initially 0xBF).

    var
    /** @type {number} */
    utf8_code_point = 0,

    /** @type {number} */
    utf8_bytes_seen = 0,

    /** @type {number} */
    utf8_bytes_needed = 0,

    /** @type {number} */
    utf8_lower_boundary = 0x80,

    /** @type {number} */
    utf8_upper_boundary = 0xBF;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,
      // set utf-8 bytes needed to 0 and return error.
      if (bite === end_of_stream && utf8_bytes_needed !== 0) {
        utf8_bytes_needed = 0;
        return decoderError(fatal);
      } // 2. If byte is end-of-stream, return finished.


      if (bite === end_of_stream) return finished; // 3. If utf-8 bytes needed is 0, based on byte:

      if (utf8_bytes_needed === 0) {
        // 0x00 to 0x7F
        if (inRange(bite, 0x00, 0x7F)) {
          // Return a code point whose value is byte.
          return bite;
        } // 0xC2 to 0xDF
        else if (inRange(bite, 0xC2, 0xDF)) {
            // 1. Set utf-8 bytes needed to 1.
            utf8_bytes_needed = 1; // 2. Set UTF-8 code point to byte & 0x1F.

            utf8_code_point = bite & 0x1F;
          } // 0xE0 to 0xEF
          else if (inRange(bite, 0xE0, 0xEF)) {
              // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.
              if (bite === 0xE0) utf8_lower_boundary = 0xA0; // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.

              if (bite === 0xED) utf8_upper_boundary = 0x9F; // 3. Set utf-8 bytes needed to 2.

              utf8_bytes_needed = 2; // 4. Set UTF-8 code point to byte & 0xF.

              utf8_code_point = bite & 0xF;
            } // 0xF0 to 0xF4
            else if (inRange(bite, 0xF0, 0xF4)) {
                // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.
                if (bite === 0xF0) utf8_lower_boundary = 0x90; // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.

                if (bite === 0xF4) utf8_upper_boundary = 0x8F; // 3. Set utf-8 bytes needed to 3.

                utf8_bytes_needed = 3; // 4. Set UTF-8 code point to byte & 0x7.

                utf8_code_point = bite & 0x7;
              } // Otherwise
              else {
                  // Return error.
                  return decoderError(fatal);
                } // Return continue.


        return null;
      } // 4. If byte is not in the range utf-8 lower boundary to utf-8
      // upper boundary, inclusive, run these substeps:


      if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {
        // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8
        // bytes seen to 0, set utf-8 lower boundary to 0x80, and set
        // utf-8 upper boundary to 0xBF.
        utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
        utf8_lower_boundary = 0x80;
        utf8_upper_boundary = 0xBF; // 2. Prepend byte to stream.

        stream.prepend(bite); // 3. Return error.

        return decoderError(fatal);
      } // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary
      // to 0xBF.


      utf8_lower_boundary = 0x80;
      utf8_upper_boundary = 0xBF; // 6. Set UTF-8 code point to (UTF-8 code point << 6) | (byte &
      // 0x3F)

      utf8_code_point = utf8_code_point << 6 | bite & 0x3F; // 7. Increase utf-8 bytes seen by one.

      utf8_bytes_seen += 1; // 8. If utf-8 bytes seen is not equal to utf-8 bytes needed,
      // continue.

      if (utf8_bytes_seen !== utf8_bytes_needed) return null; // 9. Let code point be utf-8 code point.

      var code_point = utf8_code_point; // 10. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes
      // seen to 0.

      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0; // 11. Return a code point whose value is code point.

      return code_point;
    };
  } // 9.1.2 utf-8 encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   */


  function UTF8Encoder(options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point, return a byte whose
      // value is code point.

      if (isASCIICodePoint(code_point)) return code_point; // 3. Set count and offset based on the range code point is in:

      var count, offset; // U+0080 to U+07FF, inclusive:

      if (inRange(code_point, 0x0080, 0x07FF)) {
        // 1 and 0xC0
        count = 1;
        offset = 0xC0;
      } // U+0800 to U+FFFF, inclusive:
      else if (inRange(code_point, 0x0800, 0xFFFF)) {
          // 2 and 0xE0
          count = 2;
          offset = 0xE0;
        } // U+10000 to U+10FFFF, inclusive:
        else if (inRange(code_point, 0x10000, 0x10FFFF)) {
            // 3 and 0xF0
            count = 3;
            offset = 0xF0;
          } // 4. Let bytes be a byte sequence whose first byte is (code
      // point >> (6 × count)) + offset.


      var bytes = [(code_point >> 6 * count) + offset]; // 5. Run these substeps while count is greater than 0:

      while (count > 0) {
        // 1. Set temp to code point >> (6 × (count − 1)).
        var temp = code_point >> 6 * (count - 1); // 2. Append to bytes 0x80 | (temp & 0x3F).

        bytes.push(0x80 | temp & 0x3F); // 3. Decrease count by one.

        count -= 1;
      } // 6. Return bytes bytes, in order.


      return bytes;
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['UTF-8'] = function (options) {
    return new UTF8Encoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['UTF-8'] = function (options) {
    return new UTF8Decoder(options);
  }; //
  // 10. Legacy single-byte encodings
  //
  // 10.1 single-byte decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {!Array.<number>} index The encoding index.
   * @param {{fatal: boolean}} options
   */


  function SingleByteDecoder(index, options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream, return finished.
      if (bite === end_of_stream) return finished; // 2. If byte is an ASCII byte, return a code point whose value
      // is byte.

      if (isASCIIByte(bite)) return bite; // 3. Let code point be the index code point for byte − 0x80 in
      // index single-byte.

      var code_point = index[bite - 0x80]; // 4. If code point is null, return error.

      if (code_point === null) return decoderError(fatal); // 5. Return a code point whose value is code point.

      return code_point;
    };
  } // 10.2 single-byte encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {!Array.<?number>} index The encoding index.
   * @param {{fatal: boolean}} options
   */


  function SingleByteEncoder(index, options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point, return a byte whose
      // value is code point.

      if (isASCIICodePoint(code_point)) return code_point; // 3. Let pointer be the index pointer for code point in index
      // single-byte.

      var pointer = indexPointerFor(code_point, index); // 4. If pointer is null, return error with code point.

      if (pointer === null) encoderError(code_point); // 5. Return a byte whose value is pointer + 0x80.

      return pointer + 0x80;
    };
  }

  (function () {
    if (!('encoding-indexes' in global)) return;
    encodings.forEach(function (category) {
      if (category.heading !== 'Legacy single-byte encodings') return;
      category.encodings.forEach(function (encoding) {
        var name = encoding.name;
        var idx = index(name.toLowerCase());
        /** @param {{fatal: boolean}} options */

        decoders[name] = function (options) {
          return new SingleByteDecoder(idx, options);
        };
        /** @param {{fatal: boolean}} options */


        encoders[name] = function (options) {
          return new SingleByteEncoder(idx, options);
        };
      });
    });
  })(); //
  // 11. Legacy multi-byte Chinese (simplified) encodings
  //
  // 11.1 gbk
  // 11.1.1 gbk decoder
  // gbk's decoder is gb18030's decoder.

  /** @param {{fatal: boolean}} options */


  decoders['GBK'] = function (options) {
    return new GB18030Decoder(options);
  }; // 11.1.2 gbk encoder
  // gbk's encoder is gb18030's encoder with its gbk flag set.

  /** @param {{fatal: boolean}} options */


  encoders['GBK'] = function (options) {
    return new GB18030Encoder(options, true);
  }; // 11.2 gb18030
  // 11.2.1 gb18030 decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function GB18030Decoder(options) {
    var fatal = options.fatal; // gb18030's decoder has an associated gb18030 first, gb18030
    // second, and gb18030 third (all initially 0x00).

    var
    /** @type {number} */
    gb18030_first = 0x00,

    /** @type {number} */
    gb18030_second = 0x00,

    /** @type {number} */
    gb18030_third = 0x00;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream and gb18030 first, gb18030
      // second, and gb18030 third are 0x00, return finished.
      if (bite === end_of_stream && gb18030_first === 0x00 && gb18030_second === 0x00 && gb18030_third === 0x00) {
        return finished;
      } // 2. If byte is end-of-stream, and gb18030 first, gb18030
      // second, or gb18030 third is not 0x00, set gb18030 first,
      // gb18030 second, and gb18030 third to 0x00, and return error.


      if (bite === end_of_stream && (gb18030_first !== 0x00 || gb18030_second !== 0x00 || gb18030_third !== 0x00)) {
        gb18030_first = 0x00;
        gb18030_second = 0x00;
        gb18030_third = 0x00;
        decoderError(fatal);
      }

      var code_point; // 3. If gb18030 third is not 0x00, run these substeps:

      if (gb18030_third !== 0x00) {
        // 1. Let code point be null.
        code_point = null; // 2. If byte is in the range 0x30 to 0x39, inclusive, set
        // code point to the index gb18030 ranges code point for
        // (((gb18030 first − 0x81) × 10 + gb18030 second − 0x30) ×
        // 126 + gb18030 third − 0x81) × 10 + byte − 0x30.

        if (inRange(bite, 0x30, 0x39)) {
          code_point = indexGB18030RangesCodePointFor((((gb18030_first - 0x81) * 10 + gb18030_second - 0x30) * 126 + gb18030_third - 0x81) * 10 + bite - 0x30);
        } // 3. Let buffer be a byte sequence consisting of gb18030
        // second, gb18030 third, and byte, in order.


        var buffer = [gb18030_second, gb18030_third, bite]; // 4. Set gb18030 first, gb18030 second, and gb18030 third to
        // 0x00.

        gb18030_first = 0x00;
        gb18030_second = 0x00;
        gb18030_third = 0x00; // 5. If code point is null, prepend buffer to stream and
        // return error.

        if (code_point === null) {
          stream.prepend(buffer);
          return decoderError(fatal);
        } // 6. Return a code point whose value is code point.


        return code_point;
      } // 4. If gb18030 second is not 0x00, run these substeps:


      if (gb18030_second !== 0x00) {
        // 1. If byte is in the range 0x81 to 0xFE, inclusive, set
        // gb18030 third to byte and return continue.
        if (inRange(bite, 0x81, 0xFE)) {
          gb18030_third = bite;
          return null;
        } // 2. Prepend gb18030 second followed by byte to stream, set
        // gb18030 first and gb18030 second to 0x00, and return error.


        stream.prepend([gb18030_second, bite]);
        gb18030_first = 0x00;
        gb18030_second = 0x00;
        return decoderError(fatal);
      } // 5. If gb18030 first is not 0x00, run these substeps:


      if (gb18030_first !== 0x00) {
        // 1. If byte is in the range 0x30 to 0x39, inclusive, set
        // gb18030 second to byte and return continue.
        if (inRange(bite, 0x30, 0x39)) {
          gb18030_second = bite;
          return null;
        } // 2. Let lead be gb18030 first, let pointer be null, and set
        // gb18030 first to 0x00.


        var lead = gb18030_first;
        var pointer = null;
        gb18030_first = 0x00; // 3. Let offset be 0x40 if byte is less than 0x7F and 0x41
        // otherwise.

        var offset = bite < 0x7F ? 0x40 : 0x41; // 4. If byte is in the range 0x40 to 0x7E, inclusive, or 0x80
        // to 0xFE, inclusive, set pointer to (lead − 0x81) × 190 +
        // (byte − offset).

        if (inRange(bite, 0x40, 0x7E) || inRange(bite, 0x80, 0xFE)) pointer = (lead - 0x81) * 190 + (bite - offset); // 5. Let code point be null if pointer is null and the index
        // code point for pointer in index gb18030 otherwise.

        code_point = pointer === null ? null : indexCodePointFor(pointer, index('gb18030')); // 6. If code point is null and byte is an ASCII byte, prepend
        // byte to stream.

        if (code_point === null && isASCIIByte(bite)) stream.prepend(bite); // 7. If code point is null, return error.

        if (code_point === null) return decoderError(fatal); // 8. Return a code point whose value is code point.

        return code_point;
      } // 6. If byte is an ASCII byte, return a code point whose value
      // is byte.


      if (isASCIIByte(bite)) return bite; // 7. If byte is 0x80, return code point U+20AC.

      if (bite === 0x80) return 0x20AC; // 8. If byte is in the range 0x81 to 0xFE, inclusive, set
      // gb18030 first to byte and return continue.

      if (inRange(bite, 0x81, 0xFE)) {
        gb18030_first = bite;
        return null;
      } // 9. Return error.


      return decoderError(fatal);
    };
  } // 11.2.2 gb18030 encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   * @param {boolean=} gbk_flag
   */


  function GB18030Encoder(options, gbk_flag) {
    var fatal = options.fatal; // gb18030's decoder has an associated gbk flag (initially unset).

    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point, return a byte whose
      // value is code point.

      if (isASCIICodePoint(code_point)) return code_point; // 3. If code point is U+E5E5, return error with code point.

      if (code_point === 0xE5E5) return encoderError(code_point); // 4. If the gbk flag is set and code point is U+20AC, return
      // byte 0x80.

      if (gbk_flag && code_point === 0x20AC) return 0x80; // 5. Let pointer be the index pointer for code point in index
      // gb18030.

      var pointer = indexPointerFor(code_point, index('gb18030')); // 6. If pointer is not null, run these substeps:

      if (pointer !== null) {
        // 1. Let lead be floor(pointer / 190) + 0x81.
        var lead = floor(pointer / 190) + 0x81; // 2. Let trail be pointer % 190.

        var trail = pointer % 190; // 3. Let offset be 0x40 if trail is less than 0x3F and 0x41 otherwise.

        var offset = trail < 0x3F ? 0x40 : 0x41; // 4. Return two bytes whose values are lead and trail + offset.

        return [lead, trail + offset];
      } // 7. If gbk flag is set, return error with code point.


      if (gbk_flag) return encoderError(code_point); // 8. Set pointer to the index gb18030 ranges pointer for code
      // point.

      pointer = indexGB18030RangesPointerFor(code_point); // 9. Let byte1 be floor(pointer / 10 / 126 / 10).

      var byte1 = floor(pointer / 10 / 126 / 10); // 10. Set pointer to pointer − byte1 × 10 × 126 × 10.

      pointer = pointer - byte1 * 10 * 126 * 10; // 11. Let byte2 be floor(pointer / 10 / 126).

      var byte2 = floor(pointer / 10 / 126); // 12. Set pointer to pointer − byte2 × 10 × 126.

      pointer = pointer - byte2 * 10 * 126; // 13. Let byte3 be floor(pointer / 10).

      var byte3 = floor(pointer / 10); // 14. Let byte4 be pointer − byte3 × 10.

      var byte4 = pointer - byte3 * 10; // 15. Return four bytes whose values are byte1 + 0x81, byte2 +
      // 0x30, byte3 + 0x81, byte4 + 0x30.

      return [byte1 + 0x81, byte2 + 0x30, byte3 + 0x81, byte4 + 0x30];
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['gb18030'] = function (options) {
    return new GB18030Encoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['gb18030'] = function (options) {
    return new GB18030Decoder(options);
  }; //
  // 12. Legacy multi-byte Chinese (traditional) encodings
  //
  // 12.1 Big5
  // 12.1.1 Big5 decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function Big5Decoder(options) {
    var fatal = options.fatal; // Big5's decoder has an associated Big5 lead (initially 0x00).

    var
    /** @type {number} */
    Big5_lead = 0x00;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream and Big5 lead is not 0x00, set
      // Big5 lead to 0x00 and return error.
      if (bite === end_of_stream && Big5_lead !== 0x00) {
        Big5_lead = 0x00;
        return decoderError(fatal);
      } // 2. If byte is end-of-stream and Big5 lead is 0x00, return
      // finished.


      if (bite === end_of_stream && Big5_lead === 0x00) return finished; // 3. If Big5 lead is not 0x00, let lead be Big5 lead, let
      // pointer be null, set Big5 lead to 0x00, and then run these
      // substeps:

      if (Big5_lead !== 0x00) {
        var lead = Big5_lead;
        var pointer = null;
        Big5_lead = 0x00; // 1. Let offset be 0x40 if byte is less than 0x7F and 0x62
        // otherwise.

        var offset = bite < 0x7F ? 0x40 : 0x62; // 2. If byte is in the range 0x40 to 0x7E, inclusive, or 0xA1
        // to 0xFE, inclusive, set pointer to (lead − 0x81) × 157 +
        // (byte − offset).

        if (inRange(bite, 0x40, 0x7E) || inRange(bite, 0xA1, 0xFE)) pointer = (lead - 0x81) * 157 + (bite - offset); // 3. If there is a row in the table below whose first column
        // is pointer, return the two code points listed in its second
        // column
        // Pointer | Code points
        // --------+--------------
        // 1133    | U+00CA U+0304
        // 1135    | U+00CA U+030C
        // 1164    | U+00EA U+0304
        // 1166    | U+00EA U+030C

        switch (pointer) {
          case 1133:
            return [0x00CA, 0x0304];

          case 1135:
            return [0x00CA, 0x030C];

          case 1164:
            return [0x00EA, 0x0304];

          case 1166:
            return [0x00EA, 0x030C];
        } // 4. Let code point be null if pointer is null and the index
        // code point for pointer in index Big5 otherwise.


        var code_point = pointer === null ? null : indexCodePointFor(pointer, index('big5')); // 5. If code point is null and byte is an ASCII byte, prepend
        // byte to stream.

        if (code_point === null && isASCIIByte(bite)) stream.prepend(bite); // 6. If code point is null, return error.

        if (code_point === null) return decoderError(fatal); // 7. Return a code point whose value is code point.

        return code_point;
      } // 4. If byte is an ASCII byte, return a code point whose value
      // is byte.


      if (isASCIIByte(bite)) return bite; // 5. If byte is in the range 0x81 to 0xFE, inclusive, set Big5
      // lead to byte and return continue.

      if (inRange(bite, 0x81, 0xFE)) {
        Big5_lead = bite;
        return null;
      } // 6. Return error.


      return decoderError(fatal);
    };
  } // 12.1.2 Big5 encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   */


  function Big5Encoder(options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point, return a byte whose
      // value is code point.

      if (isASCIICodePoint(code_point)) return code_point; // 3. Let pointer be the index Big5 pointer for code point.

      var pointer = indexBig5PointerFor(code_point); // 4. If pointer is null, return error with code point.

      if (pointer === null) return encoderError(code_point); // 5. Let lead be floor(pointer / 157) + 0x81.

      var lead = floor(pointer / 157) + 0x81; // 6. If lead is less than 0xA1, return error with code point.

      if (lead < 0xA1) return encoderError(code_point); // 7. Let trail be pointer % 157.

      var trail = pointer % 157; // 8. Let offset be 0x40 if trail is less than 0x3F and 0x62
      // otherwise.

      var offset = trail < 0x3F ? 0x40 : 0x62; // Return two bytes whose values are lead and trail + offset.

      return [lead, trail + offset];
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['Big5'] = function (options) {
    return new Big5Encoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['Big5'] = function (options) {
    return new Big5Decoder(options);
  }; //
  // 13. Legacy multi-byte Japanese encodings
  //
  // 13.1 euc-jp
  // 13.1.1 euc-jp decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function EUCJPDecoder(options) {
    var fatal = options.fatal; // euc-jp's decoder has an associated euc-jp jis0212 flag
    // (initially unset) and euc-jp lead (initially 0x00).

    var
    /** @type {boolean} */
    eucjp_jis0212_flag = false,

    /** @type {number} */
    eucjp_lead = 0x00;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream and euc-jp lead is not 0x00, set
      // euc-jp lead to 0x00, and return error.
      if (bite === end_of_stream && eucjp_lead !== 0x00) {
        eucjp_lead = 0x00;
        return decoderError(fatal);
      } // 2. If byte is end-of-stream and euc-jp lead is 0x00, return
      // finished.


      if (bite === end_of_stream && eucjp_lead === 0x00) return finished; // 3. If euc-jp lead is 0x8E and byte is in the range 0xA1 to
      // 0xDF, inclusive, set euc-jp lead to 0x00 and return a code
      // point whose value is 0xFF61 − 0xA1 + byte.

      if (eucjp_lead === 0x8E && inRange(bite, 0xA1, 0xDF)) {
        eucjp_lead = 0x00;
        return 0xFF61 - 0xA1 + bite;
      } // 4. If euc-jp lead is 0x8F and byte is in the range 0xA1 to
      // 0xFE, inclusive, set the euc-jp jis0212 flag, set euc-jp lead
      // to byte, and return continue.


      if (eucjp_lead === 0x8F && inRange(bite, 0xA1, 0xFE)) {
        eucjp_jis0212_flag = true;
        eucjp_lead = bite;
        return null;
      } // 5. If euc-jp lead is not 0x00, let lead be euc-jp lead, set
      // euc-jp lead to 0x00, and run these substeps:


      if (eucjp_lead !== 0x00) {
        var lead = eucjp_lead;
        eucjp_lead = 0x00; // 1. Let code point be null.

        var code_point = null; // 2. If lead and byte are both in the range 0xA1 to 0xFE,
        // inclusive, set code point to the index code point for (lead
        // − 0xA1) × 94 + byte − 0xA1 in index jis0208 if the euc-jp
        // jis0212 flag is unset and in index jis0212 otherwise.

        if (inRange(lead, 0xA1, 0xFE) && inRange(bite, 0xA1, 0xFE)) {
          code_point = indexCodePointFor((lead - 0xA1) * 94 + (bite - 0xA1), index(!eucjp_jis0212_flag ? 'jis0208' : 'jis0212'));
        } // 3. Unset the euc-jp jis0212 flag.


        eucjp_jis0212_flag = false; // 4. If byte is not in the range 0xA1 to 0xFE, inclusive,
        // prepend byte to stream.

        if (!inRange(bite, 0xA1, 0xFE)) stream.prepend(bite); // 5. If code point is null, return error.

        if (code_point === null) return decoderError(fatal); // 6. Return a code point whose value is code point.

        return code_point;
      } // 6. If byte is an ASCII byte, return a code point whose value
      // is byte.


      if (isASCIIByte(bite)) return bite; // 7. If byte is 0x8E, 0x8F, or in the range 0xA1 to 0xFE,
      // inclusive, set euc-jp lead to byte and return continue.

      if (bite === 0x8E || bite === 0x8F || inRange(bite, 0xA1, 0xFE)) {
        eucjp_lead = bite;
        return null;
      } // 8. Return error.


      return decoderError(fatal);
    };
  } // 13.1.2 euc-jp encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   */


  function EUCJPEncoder(options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point, return a byte whose
      // value is code point.

      if (isASCIICodePoint(code_point)) return code_point; // 3. If code point is U+00A5, return byte 0x5C.

      if (code_point === 0x00A5) return 0x5C; // 4. If code point is U+203E, return byte 0x7E.

      if (code_point === 0x203E) return 0x7E; // 5. If code point is in the range U+FF61 to U+FF9F, inclusive,
      // return two bytes whose values are 0x8E and code point −
      // 0xFF61 + 0xA1.

      if (inRange(code_point, 0xFF61, 0xFF9F)) return [0x8E, code_point - 0xFF61 + 0xA1]; // 6. If code point is U+2212, set it to U+FF0D.

      if (code_point === 0x2212) code_point = 0xFF0D; // 7. Let pointer be the index pointer for code point in index
      // jis0208.

      var pointer = indexPointerFor(code_point, index('jis0208')); // 8. If pointer is null, return error with code point.

      if (pointer === null) return encoderError(code_point); // 9. Let lead be floor(pointer / 94) + 0xA1.

      var lead = floor(pointer / 94) + 0xA1; // 10. Let trail be pointer % 94 + 0xA1.

      var trail = pointer % 94 + 0xA1; // 11. Return two bytes whose values are lead and trail.

      return [lead, trail];
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['EUC-JP'] = function (options) {
    return new EUCJPEncoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['EUC-JP'] = function (options) {
    return new EUCJPDecoder(options);
  }; // 13.2 iso-2022-jp
  // 13.2.1 iso-2022-jp decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function ISO2022JPDecoder(options) {
    var fatal = options.fatal;
    /** @enum */

    var states = {
      ASCII: 0,
      Roman: 1,
      Katakana: 2,
      LeadByte: 3,
      TrailByte: 4,
      EscapeStart: 5,
      Escape: 6
    }; // iso-2022-jp's decoder has an associated iso-2022-jp decoder
    // state (initially ASCII), iso-2022-jp decoder output state
    // (initially ASCII), iso-2022-jp lead (initially 0x00), and
    // iso-2022-jp output flag (initially unset).

    var
    /** @type {number} */
    iso2022jp_decoder_state = states.ASCII,

    /** @type {number} */
    iso2022jp_decoder_output_state = states.ASCII,

    /** @type {number} */
    iso2022jp_lead = 0x00,

    /** @type {boolean} */
    iso2022jp_output_flag = false;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // switching on iso-2022-jp decoder state:
      switch (iso2022jp_decoder_state) {
        default:
        case states.ASCII:
          // ASCII
          // Based on byte:
          // 0x1B
          if (bite === 0x1B) {
            // Set iso-2022-jp decoder state to escape start and return
            // continue.
            iso2022jp_decoder_state = states.EscapeStart;
            return null;
          } // 0x00 to 0x7F, excluding 0x0E, 0x0F, and 0x1B


          if (inRange(bite, 0x00, 0x7F) && bite !== 0x0E && bite !== 0x0F && bite !== 0x1B) {
            // Unset the iso-2022-jp output flag and return a code point
            // whose value is byte.
            iso2022jp_output_flag = false;
            return bite;
          } // end-of-stream


          if (bite === end_of_stream) {
            // Return finished.
            return finished;
          } // Otherwise
          // Unset the iso-2022-jp output flag and return error.


          iso2022jp_output_flag = false;
          return decoderError(fatal);

        case states.Roman:
          // Roman
          // Based on byte:
          // 0x1B
          if (bite === 0x1B) {
            // Set iso-2022-jp decoder state to escape start and return
            // continue.
            iso2022jp_decoder_state = states.EscapeStart;
            return null;
          } // 0x5C


          if (bite === 0x5C) {
            // Unset the iso-2022-jp output flag and return code point
            // U+00A5.
            iso2022jp_output_flag = false;
            return 0x00A5;
          } // 0x7E


          if (bite === 0x7E) {
            // Unset the iso-2022-jp output flag and return code point
            // U+203E.
            iso2022jp_output_flag = false;
            return 0x203E;
          } // 0x00 to 0x7F, excluding 0x0E, 0x0F, 0x1B, 0x5C, and 0x7E


          if (inRange(bite, 0x00, 0x7F) && bite !== 0x0E && bite !== 0x0F && bite !== 0x1B && bite !== 0x5C && bite !== 0x7E) {
            // Unset the iso-2022-jp output flag and return a code point
            // whose value is byte.
            iso2022jp_output_flag = false;
            return bite;
          } // end-of-stream


          if (bite === end_of_stream) {
            // Return finished.
            return finished;
          } // Otherwise
          // Unset the iso-2022-jp output flag and return error.


          iso2022jp_output_flag = false;
          return decoderError(fatal);

        case states.Katakana:
          // Katakana
          // Based on byte:
          // 0x1B
          if (bite === 0x1B) {
            // Set iso-2022-jp decoder state to escape start and return
            // continue.
            iso2022jp_decoder_state = states.EscapeStart;
            return null;
          } // 0x21 to 0x5F


          if (inRange(bite, 0x21, 0x5F)) {
            // Unset the iso-2022-jp output flag and return a code point
            // whose value is 0xFF61 − 0x21 + byte.
            iso2022jp_output_flag = false;
            return 0xFF61 - 0x21 + bite;
          } // end-of-stream


          if (bite === end_of_stream) {
            // Return finished.
            return finished;
          } // Otherwise
          // Unset the iso-2022-jp output flag and return error.


          iso2022jp_output_flag = false;
          return decoderError(fatal);

        case states.LeadByte:
          // Lead byte
          // Based on byte:
          // 0x1B
          if (bite === 0x1B) {
            // Set iso-2022-jp decoder state to escape start and return
            // continue.
            iso2022jp_decoder_state = states.EscapeStart;
            return null;
          } // 0x21 to 0x7E


          if (inRange(bite, 0x21, 0x7E)) {
            // Unset the iso-2022-jp output flag, set iso-2022-jp lead
            // to byte, iso-2022-jp decoder state to trail byte, and
            // return continue.
            iso2022jp_output_flag = false;
            iso2022jp_lead = bite;
            iso2022jp_decoder_state = states.TrailByte;
            return null;
          } // end-of-stream


          if (bite === end_of_stream) {
            // Return finished.
            return finished;
          } // Otherwise
          // Unset the iso-2022-jp output flag and return error.


          iso2022jp_output_flag = false;
          return decoderError(fatal);

        case states.TrailByte:
          // Trail byte
          // Based on byte:
          // 0x1B
          if (bite === 0x1B) {
            // Set iso-2022-jp decoder state to escape start and return
            // continue.
            iso2022jp_decoder_state = states.EscapeStart;
            return decoderError(fatal);
          } // 0x21 to 0x7E


          if (inRange(bite, 0x21, 0x7E)) {
            // 1. Set the iso-2022-jp decoder state to lead byte.
            iso2022jp_decoder_state = states.LeadByte; // 2. Let pointer be (iso-2022-jp lead − 0x21) × 94 + byte − 0x21.

            var pointer = (iso2022jp_lead - 0x21) * 94 + bite - 0x21; // 3. Let code point be the index code point for pointer in
            // index jis0208.

            var code_point = indexCodePointFor(pointer, index('jis0208')); // 4. If code point is null, return error.

            if (code_point === null) return decoderError(fatal); // 5. Return a code point whose value is code point.

            return code_point;
          } // end-of-stream


          if (bite === end_of_stream) {
            // Set the iso-2022-jp decoder state to lead byte, prepend
            // byte to stream, and return error.
            iso2022jp_decoder_state = states.LeadByte;
            stream.prepend(bite);
            return decoderError(fatal);
          } // Otherwise
          // Set iso-2022-jp decoder state to lead byte and return
          // error.


          iso2022jp_decoder_state = states.LeadByte;
          return decoderError(fatal);

        case states.EscapeStart:
          // Escape start
          // 1. If byte is either 0x24 or 0x28, set iso-2022-jp lead to
          // byte, iso-2022-jp decoder state to escape, and return
          // continue.
          if (bite === 0x24 || bite === 0x28) {
            iso2022jp_lead = bite;
            iso2022jp_decoder_state = states.Escape;
            return null;
          } // 2. Prepend byte to stream.


          stream.prepend(bite); // 3. Unset the iso-2022-jp output flag, set iso-2022-jp
          // decoder state to iso-2022-jp decoder output state, and
          // return error.

          iso2022jp_output_flag = false;
          iso2022jp_decoder_state = iso2022jp_decoder_output_state;
          return decoderError(fatal);

        case states.Escape:
          // Escape
          // 1. Let lead be iso-2022-jp lead and set iso-2022-jp lead to
          // 0x00.
          var lead = iso2022jp_lead;
          iso2022jp_lead = 0x00; // 2. Let state be null.

          var state = null; // 3. If lead is 0x28 and byte is 0x42, set state to ASCII.

          if (lead === 0x28 && bite === 0x42) state = states.ASCII; // 4. If lead is 0x28 and byte is 0x4A, set state to Roman.

          if (lead === 0x28 && bite === 0x4A) state = states.Roman; // 5. If lead is 0x28 and byte is 0x49, set state to Katakana.

          if (lead === 0x28 && bite === 0x49) state = states.Katakana; // 6. If lead is 0x24 and byte is either 0x40 or 0x42, set
          // state to lead byte.

          if (lead === 0x24 && (bite === 0x40 || bite === 0x42)) state = states.LeadByte; // 7. If state is non-null, run these substeps:

          if (state !== null) {
            // 1. Set iso-2022-jp decoder state and iso-2022-jp decoder
            // output state to states.
            iso2022jp_decoder_state = iso2022jp_decoder_state = state; // 2. Let output flag be the iso-2022-jp output flag.

            var output_flag = iso2022jp_output_flag; // 3. Set the iso-2022-jp output flag.

            iso2022jp_output_flag = true; // 4. Return continue, if output flag is unset, and error
            // otherwise.

            return !output_flag ? null : decoderError(fatal);
          } // 8. Prepend lead and byte to stream.


          stream.prepend([lead, bite]); // 9. Unset the iso-2022-jp output flag, set iso-2022-jp
          // decoder state to iso-2022-jp decoder output state and
          // return error.

          iso2022jp_output_flag = false;
          iso2022jp_decoder_state = iso2022jp_decoder_output_state;
          return decoderError(fatal);
      }
    };
  } // 13.2.2 iso-2022-jp encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   */


  function ISO2022JPEncoder(options) {
    var fatal = options.fatal; // iso-2022-jp's encoder has an associated iso-2022-jp encoder
    // state which is one of ASCII, Roman, and jis0208 (initially
    // ASCII).

    /** @enum */

    var states = {
      ASCII: 0,
      Roman: 1,
      jis0208: 2
    };
    var
    /** @type {number} */
    iso2022jp_state = states.ASCII;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream and iso-2022-jp encoder
      // state is not ASCII, prepend code point to stream, set
      // iso-2022-jp encoder state to ASCII, and return three bytes
      // 0x1B 0x28 0x42.
      if (code_point === end_of_stream && iso2022jp_state !== states.ASCII) {
        stream.prepend(code_point);
        iso2022jp_state = states.ASCII;
        return [0x1B, 0x28, 0x42];
      } // 2. If code point is end-of-stream and iso-2022-jp encoder
      // state is ASCII, return finished.


      if (code_point === end_of_stream && iso2022jp_state === states.ASCII) return finished; // 3. If ISO-2022-JP encoder state is ASCII or Roman, and code
      // point is U+000E, U+000F, or U+001B, return error with U+FFFD.

      if ((iso2022jp_state === states.ASCII || iso2022jp_state === states.Roman) && (code_point === 0x000E || code_point === 0x000F || code_point === 0x001B)) {
        return encoderError(0xFFFD);
      } // 4. If iso-2022-jp encoder state is ASCII and code point is an
      // ASCII code point, return a byte whose value is code point.


      if (iso2022jp_state === states.ASCII && isASCIICodePoint(code_point)) return code_point; // 5. If iso-2022-jp encoder state is Roman and code point is an
      // ASCII code point, excluding U+005C and U+007E, or is U+00A5
      // or U+203E, run these substeps:

      if (iso2022jp_state === states.Roman && (isASCIICodePoint(code_point) && code_point !== 0x005C && code_point !== 0x007E || code_point == 0x00A5 || code_point == 0x203E)) {
        // 1. If code point is an ASCII code point, return a byte
        // whose value is code point.
        if (isASCIICodePoint(code_point)) return code_point; // 2. If code point is U+00A5, return byte 0x5C.

        if (code_point === 0x00A5) return 0x5C; // 3. If code point is U+203E, return byte 0x7E.

        if (code_point === 0x203E) return 0x7E;
      } // 6. If code point is an ASCII code point, and iso-2022-jp
      // encoder state is not ASCII, prepend code point to stream, set
      // iso-2022-jp encoder state to ASCII, and return three bytes
      // 0x1B 0x28 0x42.


      if (isASCIICodePoint(code_point) && iso2022jp_state !== states.ASCII) {
        stream.prepend(code_point);
        iso2022jp_state = states.ASCII;
        return [0x1B, 0x28, 0x42];
      } // 7. If code point is either U+00A5 or U+203E, and iso-2022-jp
      // encoder state is not Roman, prepend code point to stream, set
      // iso-2022-jp encoder state to Roman, and return three bytes
      // 0x1B 0x28 0x4A.


      if ((code_point === 0x00A5 || code_point === 0x203E) && iso2022jp_state !== states.Roman) {
        stream.prepend(code_point);
        iso2022jp_state = states.Roman;
        return [0x1B, 0x28, 0x4A];
      } // 8. If code point is U+2212, set it to U+FF0D.


      if (code_point === 0x2212) code_point = 0xFF0D; // 9. Let pointer be the index pointer for code point in index
      // jis0208.

      var pointer = indexPointerFor(code_point, index('jis0208')); // 10. If pointer is null, return error with code point.

      if (pointer === null) return encoderError(code_point); // 11. If iso-2022-jp encoder state is not jis0208, prepend code
      // point to stream, set iso-2022-jp encoder state to jis0208,
      // and return three bytes 0x1B 0x24 0x42.

      if (iso2022jp_state !== states.jis0208) {
        stream.prepend(code_point);
        iso2022jp_state = states.jis0208;
        return [0x1B, 0x24, 0x42];
      } // 12. Let lead be floor(pointer / 94) + 0x21.


      var lead = floor(pointer / 94) + 0x21; // 13. Let trail be pointer % 94 + 0x21.

      var trail = pointer % 94 + 0x21; // 14. Return two bytes whose values are lead and trail.

      return [lead, trail];
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['ISO-2022-JP'] = function (options) {
    return new ISO2022JPEncoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['ISO-2022-JP'] = function (options) {
    return new ISO2022JPDecoder(options);
  }; // 13.3 Shift_JIS
  // 13.3.1 Shift_JIS decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function ShiftJISDecoder(options) {
    var fatal = options.fatal; // Shift_JIS's decoder has an associated Shift_JIS lead (initially
    // 0x00).

    var
    /** @type {number} */
    Shift_JIS_lead = 0x00;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream and Shift_JIS lead is not 0x00,
      // set Shift_JIS lead to 0x00 and return error.
      if (bite === end_of_stream && Shift_JIS_lead !== 0x00) {
        Shift_JIS_lead = 0x00;
        return decoderError(fatal);
      } // 2. If byte is end-of-stream and Shift_JIS lead is 0x00,
      // return finished.


      if (bite === end_of_stream && Shift_JIS_lead === 0x00) return finished; // 3. If Shift_JIS lead is not 0x00, let lead be Shift_JIS lead,
      // let pointer be null, set Shift_JIS lead to 0x00, and then run
      // these substeps:

      if (Shift_JIS_lead !== 0x00) {
        var lead = Shift_JIS_lead;
        var pointer = null;
        Shift_JIS_lead = 0x00; // 1. Let offset be 0x40, if byte is less than 0x7F, and 0x41
        // otherwise.

        var offset = bite < 0x7F ? 0x40 : 0x41; // 2. Let lead offset be 0x81, if lead is less than 0xA0, and
        // 0xC1 otherwise.

        var lead_offset = lead < 0xA0 ? 0x81 : 0xC1; // 3. If byte is in the range 0x40 to 0x7E, inclusive, or 0x80
        // to 0xFC, inclusive, set pointer to (lead − lead offset) ×
        // 188 + byte − offset.

        if (inRange(bite, 0x40, 0x7E) || inRange(bite, 0x80, 0xFC)) pointer = (lead - lead_offset) * 188 + bite - offset; // 4. If pointer is in the range 8836 to 10715, inclusive,
        // return a code point whose value is 0xE000 − 8836 + pointer.

        if (inRange(pointer, 8836, 10715)) return 0xE000 - 8836 + pointer; // 5. Let code point be null, if pointer is null, and the
        // index code point for pointer in index jis0208 otherwise.

        var code_point = pointer === null ? null : indexCodePointFor(pointer, index('jis0208')); // 6. If code point is null and byte is an ASCII byte, prepend
        // byte to stream.

        if (code_point === null && isASCIIByte(bite)) stream.prepend(bite); // 7. If code point is null, return error.

        if (code_point === null) return decoderError(fatal); // 8. Return a code point whose value is code point.

        return code_point;
      } // 4. If byte is an ASCII byte or 0x80, return a code point
      // whose value is byte.


      if (isASCIIByte(bite) || bite === 0x80) return bite; // 5. If byte is in the range 0xA1 to 0xDF, inclusive, return a
      // code point whose value is 0xFF61 − 0xA1 + byte.

      if (inRange(bite, 0xA1, 0xDF)) return 0xFF61 - 0xA1 + bite; // 6. If byte is in the range 0x81 to 0x9F, inclusive, or 0xE0
      // to 0xFC, inclusive, set Shift_JIS lead to byte and return
      // continue.

      if (inRange(bite, 0x81, 0x9F) || inRange(bite, 0xE0, 0xFC)) {
        Shift_JIS_lead = bite;
        return null;
      } // 7. Return error.


      return decoderError(fatal);
    };
  } // 13.3.2 Shift_JIS encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   */


  function ShiftJISEncoder(options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point or U+0080, return a
      // byte whose value is code point.

      if (isASCIICodePoint(code_point) || code_point === 0x0080) return code_point; // 3. If code point is U+00A5, return byte 0x5C.

      if (code_point === 0x00A5) return 0x5C; // 4. If code point is U+203E, return byte 0x7E.

      if (code_point === 0x203E) return 0x7E; // 5. If code point is in the range U+FF61 to U+FF9F, inclusive,
      // return a byte whose value is code point − 0xFF61 + 0xA1.

      if (inRange(code_point, 0xFF61, 0xFF9F)) return code_point - 0xFF61 + 0xA1; // 6. If code point is U+2212, set it to U+FF0D.

      if (code_point === 0x2212) code_point = 0xFF0D; // 7. Let pointer be the index Shift_JIS pointer for code point.

      var pointer = indexShiftJISPointerFor(code_point); // 8. If pointer is null, return error with code point.

      if (pointer === null) return encoderError(code_point); // 9. Let lead be floor(pointer / 188).

      var lead = floor(pointer / 188); // 10. Let lead offset be 0x81, if lead is less than 0x1F, and
      // 0xC1 otherwise.

      var lead_offset = lead < 0x1F ? 0x81 : 0xC1; // 11. Let trail be pointer % 188.

      var trail = pointer % 188; // 12. Let offset be 0x40, if trail is less than 0x3F, and 0x41
      // otherwise.

      var offset = trail < 0x3F ? 0x40 : 0x41; // 13. Return two bytes whose values are lead + lead offset and
      // trail + offset.

      return [lead + lead_offset, trail + offset];
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['Shift_JIS'] = function (options) {
    return new ShiftJISEncoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['Shift_JIS'] = function (options) {
    return new ShiftJISDecoder(options);
  }; //
  // 14. Legacy multi-byte Korean encodings
  //
  // 14.1 euc-kr
  // 14.1.1 euc-kr decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function EUCKRDecoder(options) {
    var fatal = options.fatal; // euc-kr's decoder has an associated euc-kr lead (initially 0x00).

    var
    /** @type {number} */
    euckr_lead = 0x00;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream and euc-kr lead is not 0x00, set
      // euc-kr lead to 0x00 and return error.
      if (bite === end_of_stream && euckr_lead !== 0) {
        euckr_lead = 0x00;
        return decoderError(fatal);
      } // 2. If byte is end-of-stream and euc-kr lead is 0x00, return
      // finished.


      if (bite === end_of_stream && euckr_lead === 0) return finished; // 3. If euc-kr lead is not 0x00, let lead be euc-kr lead, let
      // pointer be null, set euc-kr lead to 0x00, and then run these
      // substeps:

      if (euckr_lead !== 0x00) {
        var lead = euckr_lead;
        var pointer = null;
        euckr_lead = 0x00; // 1. If byte is in the range 0x41 to 0xFE, inclusive, set
        // pointer to (lead − 0x81) × 190 + (byte − 0x41).

        if (inRange(bite, 0x41, 0xFE)) pointer = (lead - 0x81) * 190 + (bite - 0x41); // 2. Let code point be null, if pointer is null, and the
        // index code point for pointer in index euc-kr otherwise.

        var code_point = pointer === null ? null : indexCodePointFor(pointer, index('euc-kr')); // 3. If code point is null and byte is an ASCII byte, prepend
        // byte to stream.

        if (pointer === null && isASCIIByte(bite)) stream.prepend(bite); // 4. If code point is null, return error.

        if (code_point === null) return decoderError(fatal); // 5. Return a code point whose value is code point.

        return code_point;
      } // 4. If byte is an ASCII byte, return a code point whose value
      // is byte.


      if (isASCIIByte(bite)) return bite; // 5. If byte is in the range 0x81 to 0xFE, inclusive, set
      // euc-kr lead to byte and return continue.

      if (inRange(bite, 0x81, 0xFE)) {
        euckr_lead = bite;
        return null;
      } // 6. Return error.


      return decoderError(fatal);
    };
  } // 14.1.2 euc-kr encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   */


  function EUCKREncoder(options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point, return a byte whose
      // value is code point.

      if (isASCIICodePoint(code_point)) return code_point; // 3. Let pointer be the index pointer for code point in index
      // euc-kr.

      var pointer = indexPointerFor(code_point, index('euc-kr')); // 4. If pointer is null, return error with code point.

      if (pointer === null) return encoderError(code_point); // 5. Let lead be floor(pointer / 190) + 0x81.

      var lead = floor(pointer / 190) + 0x81; // 6. Let trail be pointer % 190 + 0x41.

      var trail = pointer % 190 + 0x41; // 7. Return two bytes whose values are lead and trail.

      return [lead, trail];
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['EUC-KR'] = function (options) {
    return new EUCKREncoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['EUC-KR'] = function (options) {
    return new EUCKRDecoder(options);
  }; //
  // 15. Legacy miscellaneous encodings
  //
  // 15.1 replacement
  // Not needed - API throws RangeError
  // 15.2 Common infrastructure for utf-16be and utf-16le

  /**
   * @param {number} code_unit
   * @param {boolean} utf16be
   * @return {!Array.<number>} bytes
   */


  function convertCodeUnitToBytes(code_unit, utf16be) {
    // 1. Let byte1 be code unit >> 8.
    var byte1 = code_unit >> 8; // 2. Let byte2 be code unit & 0x00FF.

    var byte2 = code_unit & 0x00FF; // 3. Then return the bytes in order:
    // utf-16be flag is set: byte1, then byte2.

    if (utf16be) return [byte1, byte2]; // utf-16be flag is unset: byte2, then byte1.

    return [byte2, byte1];
  } // 15.2.1 shared utf-16 decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {boolean} utf16_be True if big-endian, false if little-endian.
   * @param {{fatal: boolean}} options
   */


  function UTF16Decoder(utf16_be, options) {
    var fatal = options.fatal;
    var
    /** @type {?number} */
    utf16_lead_byte = null,

    /** @type {?number} */
    utf16_lead_surrogate = null;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream and either utf-16 lead byte or
      // utf-16 lead surrogate is not null, set utf-16 lead byte and
      // utf-16 lead surrogate to null, and return error.
      if (bite === end_of_stream && (utf16_lead_byte !== null || utf16_lead_surrogate !== null)) {
        return decoderError(fatal);
      } // 2. If byte is end-of-stream and utf-16 lead byte and utf-16
      // lead surrogate are null, return finished.


      if (bite === end_of_stream && utf16_lead_byte === null && utf16_lead_surrogate === null) {
        return finished;
      } // 3. If utf-16 lead byte is null, set utf-16 lead byte to byte
      // and return continue.


      if (utf16_lead_byte === null) {
        utf16_lead_byte = bite;
        return null;
      } // 4. Let code unit be the result of:


      var code_unit;

      if (utf16_be) {
        // utf-16be decoder flag is set
        //   (utf-16 lead byte << 8) + byte.
        code_unit = (utf16_lead_byte << 8) + bite;
      } else {
        // utf-16be decoder flag is unset
        //   (byte << 8) + utf-16 lead byte.
        code_unit = (bite << 8) + utf16_lead_byte;
      } // Then set utf-16 lead byte to null.


      utf16_lead_byte = null; // 5. If utf-16 lead surrogate is not null, let lead surrogate
      // be utf-16 lead surrogate, set utf-16 lead surrogate to null,
      // and then run these substeps:

      if (utf16_lead_surrogate !== null) {
        var lead_surrogate = utf16_lead_surrogate;
        utf16_lead_surrogate = null; // 1. If code unit is in the range U+DC00 to U+DFFF,
        // inclusive, return a code point whose value is 0x10000 +
        // ((lead surrogate − 0xD800) << 10) + (code unit − 0xDC00).

        if (inRange(code_unit, 0xDC00, 0xDFFF)) {
          return 0x10000 + (lead_surrogate - 0xD800) * 0x400 + (code_unit - 0xDC00);
        } // 2. Prepend the sequence resulting of converting code unit
        // to bytes using utf-16be decoder flag to stream and return
        // error.


        stream.prepend(convertCodeUnitToBytes(code_unit, utf16_be));
        return decoderError(fatal);
      } // 6. If code unit is in the range U+D800 to U+DBFF, inclusive,
      // set utf-16 lead surrogate to code unit and return continue.


      if (inRange(code_unit, 0xD800, 0xDBFF)) {
        utf16_lead_surrogate = code_unit;
        return null;
      } // 7. If code unit is in the range U+DC00 to U+DFFF, inclusive,
      // return error.


      if (inRange(code_unit, 0xDC00, 0xDFFF)) return decoderError(fatal); // 8. Return code point code unit.

      return code_unit;
    };
  } // 15.2.2 shared utf-16 encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {boolean} utf16_be True if big-endian, false if little-endian.
   * @param {{fatal: boolean}} options
   */


  function UTF16Encoder(utf16_be, options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1. If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is in the range U+0000 to U+FFFF, inclusive,
      // return the sequence resulting of converting code point to
      // bytes using utf-16be encoder flag.

      if (inRange(code_point, 0x0000, 0xFFFF)) return convertCodeUnitToBytes(code_point, utf16_be); // 3. Let lead be ((code point − 0x10000) >> 10) + 0xD800,
      // converted to bytes using utf-16be encoder flag.

      var lead = convertCodeUnitToBytes((code_point - 0x10000 >> 10) + 0xD800, utf16_be); // 4. Let trail be ((code point − 0x10000) & 0x3FF) + 0xDC00,
      // converted to bytes using utf-16be encoder flag.

      var trail = convertCodeUnitToBytes((code_point - 0x10000 & 0x3FF) + 0xDC00, utf16_be); // 5. Return a byte sequence of lead followed by trail.

      return lead.concat(trail);
    };
  } // 15.3 utf-16be
  // 15.3.1 utf-16be decoder

  /** @param {{fatal: boolean}} options */


  encoders['UTF-16BE'] = function (options) {
    return new UTF16Encoder(true, options);
  }; // 15.3.2 utf-16be encoder

  /** @param {{fatal: boolean}} options */


  decoders['UTF-16BE'] = function (options) {
    return new UTF16Decoder(true, options);
  }; // 15.4 utf-16le
  // 15.4.1 utf-16le decoder

  /** @param {{fatal: boolean}} options */


  encoders['UTF-16LE'] = function (options) {
    return new UTF16Encoder(false, options);
  }; // 15.4.2 utf-16le encoder

  /** @param {{fatal: boolean}} options */


  decoders['UTF-16LE'] = function (options) {
    return new UTF16Decoder(false, options);
  }; // 15.5 x-user-defined
  // 15.5.1 x-user-defined decoder

  /**
   * @constructor
   * @implements {Decoder}
   * @param {{fatal: boolean}} options
   */


  function XUserDefinedDecoder(options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream The stream of bytes being decoded.
     * @param {number} bite The next byte read from the stream.
     * @return {?(number|!Array.<number>)} The next code point(s)
     *     decoded, or null if not enough data exists in the input
     *     stream to decode a complete code point.
     */

    this.handler = function (stream, bite) {
      // 1. If byte is end-of-stream, return finished.
      if (bite === end_of_stream) return finished; // 2. If byte is an ASCII byte, return a code point whose value
      // is byte.

      if (isASCIIByte(bite)) return bite; // 3. Return a code point whose value is 0xF780 + byte − 0x80.

      return 0xF780 + bite - 0x80;
    };
  } // 15.5.2 x-user-defined encoder

  /**
   * @constructor
   * @implements {Encoder}
   * @param {{fatal: boolean}} options
   */


  function XUserDefinedEncoder(options) {
    var fatal = options.fatal;
    /**
     * @param {Stream} stream Input stream.
     * @param {number} code_point Next code point read from the stream.
     * @return {(number|!Array.<number>)} Byte(s) to emit.
     */

    this.handler = function (stream, code_point) {
      // 1.If code point is end-of-stream, return finished.
      if (code_point === end_of_stream) return finished; // 2. If code point is an ASCII code point, return a byte whose
      // value is code point.

      if (isASCIICodePoint(code_point)) return code_point; // 3. If code point is in the range U+F780 to U+F7FF, inclusive,
      // return a byte whose value is code point − 0xF780 + 0x80.

      if (inRange(code_point, 0xF780, 0xF7FF)) return code_point - 0xF780 + 0x80; // 4. Return error with code point.

      return encoderError(code_point);
    };
  }
  /** @param {{fatal: boolean}} options */


  encoders['x-user-defined'] = function (options) {
    return new XUserDefinedEncoder(options);
  };
  /** @param {{fatal: boolean}} options */


  decoders['x-user-defined'] = function (options) {
    return new XUserDefinedDecoder(options);
  };

  if (!global['TextEncoder']) global['TextEncoder'] = TextEncoder;
  if (!global['TextDecoder']) global['TextDecoder'] = TextDecoder;

  if (typeof module !== "undefined" && module.exports) {
    module.exports = {
      TextEncoder: global['TextEncoder'],
      TextDecoder: global['TextDecoder'],
      EncodingIndexes: global["encoding-indexes"]
    };
  } // For strict environments where `this` inside the global scope
  // is `undefined`, take a pure object instead

})(this || {});